const a: i64 = 1664525;
const c: i64 = 1013904223;
const m: i64 = 4294967296; // 2^32
let seed: i64 = 1; // 固定种子以确保结果可重现

function myRandom(): f64 {
    seed = (a * seed + c) % m;
    return seed / m as f64; // 返回0到1之间的数
}

export function mulMatrix(n: i32): void {
    // 初始化矩阵A
    let A: Float64Array = new Float64Array(n * n);
    let APtr: usize = changetype<usize>(A.buffer);

    // 初始化矩阵B
    let B: Float64Array = new Float64Array(n * n);
    let BPtr: usize = changetype<usize>(B.buffer);

    // 初始化矩阵C
    let C: Float64Array = new Float64Array(n * n);
    let CPtr: usize = changetype<usize>(C.buffer);

    // 填充矩阵A
    for (let i = 0; i < n; i++) {
        for (let j = 0; j < n; j++) {
            let value = myRandom();
            store<f64>(APtr + (i * n + j) * 8, value);
        }
    }

    // 填充矩阵B
    for (let i = 0; i < n; i++) {
        for (let j = 0; j < n; j++) {
            let value = myRandom();
            store<f64>(BPtr + (i * n + j) * 8, value);
        }
    }

    // 初始化矩阵C为0
    for (let i = 0; i < n; i++) {
        for (let j = 0; j < n; j++) {
            store<f64>(CPtr + (i * n + j) * 8, 0);
        }
    }

    // 矩阵乘法
    for (let i = 0; i < n; i++) {
        for (let j = 0; j < n; j++) {
            for (let k = 0; k < n; k++) {
                let Apk = load<f64>(APtr + (i * n + k) * 8);
                let Bkj = load<f64>(BPtr + (k * n + j) * 8);
                let Cij = load<f64>(CPtr + (i * n + j) * 8);
                store<f64>(CPtr + (i * n + j) * 8, Cij + Apk * Bkj);
            }
        }
    }
}